டைப்ஸ்கிரிப்ட் பார்ஷியல் வகைகளில் தேர்ச்சி: நெகிழ்வுத்தன்மைக்காக பண்புகளை மாற்றுதல்

டைப்ஸ்கிரிப்ட், ஜாவாஸ்கிரிப்டின் ஒரு சூப்பர்செட், வலை மேம்பாட்டின் மாறும் உலகிற்கு நிலையான வகையிடலைக் கொண்டுவருகிறது. இதன் சக்திவாய்ந்த அம்சங்களில் ஒன்று Partial வகை. இது ஏற்கனவே உள்ள ஒரு வகையின் அனைத்து பண்புகளையும் விருப்பமானதாக (optional) மாற்றும் ஒரு புதிய வகையை உருவாக்க உங்களை அனுமதிக்கிறது. தரவு, ஆப்ஜெக்ட் கையாளுதல் மற்றும் API தொடர்புகளுடன் பணிபுரியும்போது இந்த திறன் ஒரு பெரிய நெகிழ்வுத்தன்மையை வழங்குகிறது. இந்த கட்டுரை Partial வகையை ஆழமாக ஆராய்ந்து, உங்கள் டைப்ஸ்கிரிப்ட் திட்டங்களில் அதை திறம்பட பயன்படுத்துவதற்கான நடைமுறை எடுத்துக்காட்டுகள் மற்றும் சிறந்த நடைமுறைகளை வழங்குகிறது.

டைப்ஸ்கிரிப்ட் பார்ஷியல் வகை என்றால் என்ன?

Partial<T> வகை என்பது டைப்ஸ்கிரிப்ட்டில் உள்ள ஒரு உள்ளமைக்கப்பட்ட பயன்பாட்டு வகையாகும். இது ஒரு T வகையை அதன் ஜெனரிக் ஆர்குமென்டாக எடுத்து, T-யின் அனைத்து பண்புகளும் விருப்பமானதாக இருக்கும் ஒரு புதிய வகையைத் தருகிறது. அடிப்படையில், இது ஒவ்வொரு பண்பையும் required என்பதிலிருந்து optional ஆக மாற்றுகிறது, அதாவது அந்த வகையின் ஒரு ஆப்ஜெக்டை உருவாக்கும்போது அவை கண்டிப்பாக இருக்க வேண்டிய அவசியமில்லை.

பின்வரும் உதாரணத்தைக் கவனியுங்கள்:

interface User {
  id: number;
  name: string;
  email: string;
  country: string;
}

const user: User = {
  id: 123,
  name: "Alice",
  email: "alice@example.com",
  country: "USA",
};

இப்போது, User வகையின் ஒரு Partial பதிப்பை உருவாக்குவோம்:

type PartialUser = Partial<User>;

const partialUser: PartialUser = {
  name: "Bob",
};

const anotherPartialUser: PartialUser = {
  id: 456,
  email: "bob@example.com",
};

const emptyUser: PartialUser = {}; // Valid

இந்த எடுத்துக்காட்டில், PartialUser ஆனது id?, name?, email?, மற்றும் country? ஆகிய பண்புகளைக் கொண்டுள்ளது. இதன் பொருள், இந்த பண்புகளில் ஏதேனும் ஒரு கலவையுடன், அல்லது எதுவுமே இல்லாமல் PartialUser வகையின் ஆப்ஜெக்ட்களை நீங்கள் உருவாக்கலாம். emptyUser ஒதுக்கீடு இதைக் காட்டுகிறது, இது Partial-இன் ஒரு முக்கிய அம்சத்தை எடுத்துக்காட்டுகிறது: இது அனைத்து பண்புகளையும் விருப்பமானதாக மாற்றுகிறது.

பார்ஷியல் வகைகளை ஏன் பயன்படுத்த வேண்டும்?

Partial வகைகள் பல சூழ்நிலைகளில் மதிப்புமிக்கவை:

• ஆப்ஜெக்ட்களை படிப்படியாகப் புதுப்பித்தல்: ஏற்கனவே உள்ள ஒரு ஆப்ஜெக்டைப் புதுப்பிக்கும்போது, அதன் பண்புகளில் ஒரு பகுதியை மட்டுமே நீங்கள் மாற்ற விரும்புவீர்கள். Partial நீங்கள் மாற்ற விரும்பும் பண்புகளுடன் மட்டுமே புதுப்பிப்பு பேலோடை வரையறுக்க அனுமதிக்கிறது.
• விருப்ப அளவுருக்கள்: செயல்பாட்டு அளவுருக்களில், Partial சில அளவுருக்களை விருப்பமானதாக மாற்றும், இது செயல்பாடு எவ்வாறு அழைக்கப்படுகிறது என்பதில் அதிக நெகிழ்வுத்தன்மையை வழங்குகிறது.
• ஆப்ஜெக்ட்களைப் படிப்படியாக உருவாக்குதல்: ஒரு சிக்கலான ஆப்ஜெக்டை உருவாக்கும்போது, எல்லா தரவுகளும் ஒரே நேரத்தில் கிடைக்காமல் இருக்கலாம். Partial ஆப்ஜெக்டை பகுதி பகுதியாக உருவாக்க உதவுகிறது.
• API-களுடன் வேலை செய்தல்: API-கள் பெரும்பாலும் சில புலங்கள் விடுபட்ட அல்லது பூஜ்யமாக இருக்கும் தரவை வழங்குகின்றன. Partial இந்த சூழ்நிலைகளை கடுமையான வகை அமலாக்கம் இல்லாமல் அழகாக கையாள உதவுகிறது.

பார்ஷியல் வகைகளின் நடைமுறை எடுத்துக்காட்டுகள்

1. ஒரு பயனர் சுயவிவரத்தைப் புதுப்பித்தல்

ஒரு பயனரின் சுயவிவரத்தைப் புதுப்பிக்கும் ஒரு செயல்பாடு உங்களிடம் இருப்பதாக கற்பனை செய்து பாருங்கள். ஒவ்வொரு முறையும் அந்தச் செயல்பாடு அனைத்து பயனர் பண்புகளையும் பெற வேண்டும் என்று நீங்கள் விரும்பவில்லை; பதிலாக, குறிப்பிட்ட புலங்களுக்கு புதுப்பிப்புகளை அனுமதிக்க விரும்புகிறீர்கள்.

interface UserProfile {
  firstName: string;
  lastName: string;
  age: number;
  country: string;
  occupation: string;
}

function updateUserProfile(userId: number, updates: Partial<UserProfile>): void {
  // Simulate updating the user profile in a database
  console.log(`Updating user ${userId} with:`, updates);
}

updateUserProfile(1, { firstName: "David" });
updateUserProfile(2, { lastName: "Smith", age: 35 });
updateUserProfile(3, { country: "Canada", occupation: "Software Engineer" });

இந்த நிலையில், Partial<UserProfile> வகைப்ப் பிழைகள் ஏற்படாமல், புதுப்பிக்கப்பட வேண்டிய பண்புகளை மட்டும் அனுப்ப உங்களை அனுமதிக்கிறது.

2. ஒரு API-க்கான கோரிக்கை ஆப்ஜெக்டை உருவாக்குதல்

API கோரிக்கைகளைச் செய்யும்போது, உங்களுக்கு விருப்ப அளவுருக்கள் இருக்கலாம். Partial பயன்படுத்துவது கோரிக்கை ஆப்ஜெக்டை உருவாக்குவதை எளிதாக்கும்.

interface SearchParams {
  query: string;
  category?: string;
  location?: string;
  page?: number;
  pageSize?: number;
}

function searchItems(params: Partial<SearchParams>): void {
  // Simulate an API call
  console.log("Searching with parameters:", params);
}

searchItems({ query: "laptop" });
searchItems({ query: "phone", category: "electronics" });
searchItems({ query: "book", location: "London", page: 2 });

இங்கே, SearchParams சாத்தியமான தேடல் அளவுருக்களை வரையறுக்கிறது. Partial<SearchParams>-ஐப் பயன்படுத்துவதன் மூலம், தேவையான அளவுருக்களுடன் மட்டுமே கோரிக்கை ஆப்ஜெக்ட்களை உருவாக்க முடியும், இது செயல்பாட்டை மேலும் பல்துறைத்திறன் கொண்டதாக ஆக்குகிறது.

3. ஒரு படிவ ஆப்ஜெக்டை உருவாக்குதல்

படிவங்களைக் கையாளும்போது, குறிப்பாக பல-படி படிவங்களில், Partial-ஐப் பயன்படுத்துவது மிகவும் பயனுள்ளதாக இருக்கும். நீங்கள் படிவத் தரவை ஒரு Partial ஆப்ஜெக்டாகக் குறிப்பிடலாம் மற்றும் பயனர் படிவத்தை நிரப்பும்போது அதை படிப்படியாக நிரப்பலாம்.

interface AddressForm {
  street: string;
  city: string;
  postalCode: string;
  country: string;
}

let form: Partial<AddressForm> = {};

form.street = "123 Main St";
form.city = "Anytown";
form.postalCode = "12345";
form.country = "USA";

console.log("Form data:", form);

படிவம் சிக்கலானதாகவும், பயனர் எல்லா புலங்களையும் ஒரே நேரத்தில் நிரப்பாமல் இருக்கும்போதும் இந்த அணுகுமுறை உதவியாக இருக்கும்.

பார்ஷியலை மற்ற பயன்பாட்டு வகைகளுடன் இணைத்தல்

Partial-ஐ மற்ற டைப்ஸ்கிரிப்ட் பயன்பாட்டு வகைகளுடன் இணைத்து மேலும் சிக்கலான மற்றும் தனிப்பயனாக்கப்பட்ட வகை மாற்றங்களை உருவாக்கலாம். சில பயனுள்ள இணைப்புகள் பின்வருமாறு:

• Partial<Pick<T, K>>: குறிப்பிட்ட பண்புகளை விருப்பமானதாக மாற்றுகிறது. Pick<T, K> என்பது T-யிலிருந்து பண்புகளின் ஒரு துணைக்குழுவைத் தேர்ந்தெடுக்கிறது, பின்னர் Partial அந்தத் தேர்ந்தெடுக்கப்பட்ட பண்புகளை விருப்பமானதாக மாற்றுகிறது.
• Required<Partial<T>>: இது முரண்பாடாகத் தோன்றினாலும், ஒரு ஆப்ஜெக்ட் "முழுமையடைந்த" பிறகு எல்லா பண்புகளும் உள்ளன என்பதை உறுதிப்படுத்த விரும்பும் சூழ்நிலைகளில் இது பயனுள்ளதாக இருக்கும். ஆப்ஜெக்டை உருவாக்கும்போது நீங்கள் ஒரு Partial<T>-உடன் தொடங்கலாம், பின்னர் அதைச் சேமிப்பதற்கு அல்லது செயலாக்குவதற்கு முன்பு எல்லா புலங்களும் நிரப்பப்பட்டுள்ளன என்பதைச் சரிபார்க்க Required<Partial<T>>-ஐப் பயன்படுத்தலாம்.
• Readonly<Partial<T>>: எல்லா பண்புகளும் விருப்பமானதாகவும் படிக்க மட்டுமேயானதாகவும் (read-only) இருக்கும் ஒரு வகையை உருவாக்குகிறது. பகுதி பகுதியாக நிரப்பக்கூடிய ஆனால் ஆரம்ப உருவாக்கத்திற்குப் பிறகு மாற்றப்படக்கூடாத ஒரு ஆப்ஜெக்டை நீங்கள் வரையறுக்க வேண்டியிருக்கும் போது இது நன்மை பயக்கும்.

எடுத்துக்காட்டு: பார்ஷியலுடன் பிக்

ஒரு புதுப்பிப்பின் போது User-இன் சில பண்புகளை மட்டும் விருப்பமானதாக மாற்ற விரும்புகிறீர்கள் என்று வைத்துக்கொள்வோம். நீங்கள் Partial<Pick<User, 'name' | 'email'>>-ஐப் பயன்படுத்தலாம்.

interface User {
  id: number;
  name: string;
  email: string;
  country: string;
}


type NameEmailUpdate = Partial<Pick<User, 'name' | 'email'>>;

const update: NameEmailUpdate = {
  name: "Charlie",
  // country இங்கே அனுமதிக்கப்படவில்லை, பெயர் மற்றும் மின்னஞ்சல் மட்டுமே
};

const update2: NameEmailUpdate = {
  email: "charlie@example.com"
};

பார்ஷியல் வகைகளைப் பயன்படுத்தும் போது சிறந்த நடைமுறைகள்

• கவனத்துடன் பயன்படுத்தவும்: Partial நெகிழ்வுத்தன்மையை வழங்கினாலும், அதிகப்படியான பயன்பாடு குறைவான கடுமையான வகைச் சரிபார்ப்பு மற்றும் சாத்தியமான இயக்க நேரப் பிழைகளுக்கு வழிவகுக்கும். உங்களுக்கு உண்மையிலேயே விருப்பப் பண்புகள் தேவைப்படும்போது மட்டுமே அதைப் பயன்படுத்தவும்.
• மாற்று வழிகளைக் கருத்தில் கொள்ளுங்கள்: Partial-ஐப் பயன்படுத்துவதற்கு முன்பு, யூனியன் வகைகள் அல்லது இன்டர்ஃபேஸில் நேரடியாக வரையறுக்கப்பட்ட விருப்பப் பண்புகள் போன்ற பிற நுட்பங்கள் மிகவும் பொருத்தமானவையா என்பதை மதிப்பீடு செய்யுங்கள்.
• தெளிவாக ஆவணப்படுத்துங்கள்: Partial-ஐப் பயன்படுத்தும்போது, அது ஏன் பயன்படுத்தப்படுகிறது மற்றும் எந்த பண்புகள் விருப்பமானதாக இருக்கும் என்று எதிர்பார்க்கப்படுகிறது என்பதைத் தெளிவாக ஆவணப்படுத்துங்கள். இது மற்ற டெவலப்பர்கள் நோக்கத்தைப் புரிந்துகொள்ளவும் தவறான பயன்பாட்டைத் தவிர்க்கவும் உதவுகிறது.
• தரவைச் சரிபார்க்கவும்: Partial பண்புகளை விருப்பமானதாக மாற்றுவதால், எதிர்பாராத நடத்தையைத் தடுக்க அதைப் பயன்படுத்துவதற்கு முன்பு தரவைச் சரிபார்க்கவும். தேவையான பண்புகள் தேவைப்படும்போது உள்ளன என்பதை உறுதிப்படுத்த வகை காவலர்கள் (type guards) அல்லது இயக்க நேரச் சரிபார்ப்புகளைப் பயன்படுத்தவும்.
• பில்டர் பேட்டர்னைப் பயன்படுத்துவதைக் கருத்தில் கொள்ளுங்கள்: சிக்கலான ஆப்ஜெக்ட் உருவாக்கத்திற்கு, ஆப்ஜெக்டை உருவாக்க பில்டர் பேட்டர்னைப் பயன்படுத்துவதைக் கருத்தில் கொள்ளுங்கள். ஒரு ஆப்ஜெக்டை படிப்படியாக உருவாக்க `Partial`-ஐப் பயன்படுத்துவதற்கு இது பெரும்பாலும் தெளிவான மற்றும் பராமரிக்கக்கூடிய மாற்றாக இருக்கும்.

உலகளாவிய பரிசீலனைகள் மற்றும் எடுத்துக்காட்டுகள்

உலகளாவிய பயன்பாடுகளுடன் பணிபுரியும்போது, வெவ்வேறு பிராந்தியங்கள் மற்றும் கலாச்சார சூழல்களில் Partial வகைகளை எவ்வாறு திறம்பட பயன்படுத்தலாம் என்பதைக் கருத்தில் கொள்வது அவசியம்.

எடுத்துக்காட்டு: சர்வதேச முகவரிப் படிவங்கள்

முகவரி வடிவங்கள் நாடுகளுக்கு இடையே கணிசமாக வேறுபடுகின்றன. சில நாடுகள் குறிப்பிட்ட முகவரிக் கூறுகளைக் கோருகின்றன, மற்றவை வெவ்வேறு அஞ்சல் குறியீட்டு முறைகளைப் பயன்படுத்துகின்றன. Partial-ஐப் பயன்படுத்துவது இந்த வேறுபாடுகளுக்கு இடமளிக்கும்.

interface InternationalAddress {
  streetAddress: string;
  apartmentNumber?: string; // சில நாடுகளில் விருப்பமானது
  city: string;
  region?: string; // மாகாணம், மாநிலம், போன்றவை.
  postalCode: string;
  country: string;
  addressFormat?: string; // நாட்டின் அடிப்படையில் காட்சி வடிவத்தைக் குறிப்பிட
}


function formatAddress(address: InternationalAddress): string {
  let formattedAddress = "";

  switch (address.addressFormat) {
    case "UK":
      formattedAddress = `${address.streetAddress}\n${address.city}\n${address.postalCode}\n${address.country}`;
      break;
    case "USA":
      formattedAddress = `${address.streetAddress}\n${address.city}, ${address.region} ${address.postalCode}\n${address.country}`;
      break;
    case "Japan":
      formattedAddress = `${address.postalCode}\n${address.region}${address.city}\n${address.streetAddress}\n${address.country}`;
      break;
    default:
      formattedAddress = `${address.streetAddress}\n${address.city}\n${address.postalCode}\n${address.country}`;
  }
  return formattedAddress;
}

const ukAddress: Partial<InternationalAddress> = {
  streetAddress: "10 Downing Street",
  city: "London",
  postalCode: "SW1A 2AA",
  country: "United Kingdom",
  addressFormat: "UK"
};

const usaAddress: Partial<InternationalAddress> = {
    streetAddress: "1600 Pennsylvania Avenue NW",
    city: "Washington",
    region: "DC",
    postalCode: "20500",
    country: "USA",
    addressFormat: "USA"
};

console.log("UK Address:\n", formatAddress(ukAddress as InternationalAddress));
console.log("USA Address:\n", formatAddress(usaAddress as InternationalAddress));

InternationalAddress இன்டர்ஃபேஸ், உலகெங்கிலும் உள்ள வெவ்வேறு முகவரி வடிவங்களுக்கு இடமளிக்க apartmentNumber மற்றும் region போன்ற விருப்பப் புலங்களை அனுமதிக்கிறது. addressFormat புலம் நாட்டின் அடிப்படையில் முகவரி எவ்வாறு காட்டப்படுகிறது என்பதைத் தனிப்பயனாக்கப் பயன்படுகிறது.

எடுத்துக்காட்டு: வெவ்வேறு பிராந்தியங்களில் பயனர் விருப்பத்தேர்வுகள்

பயனர் விருப்பத்தேர்வுகள் பிராந்தியங்களுக்கு இடையில் மாறுபடலாம். சில விருப்பத்தேர்வுகள் குறிப்பிட்ட நாடுகள் அல்லது கலாச்சாரங்களில் மட்டுமே பொருத்தமானதாக இருக்கலாம்.

interface UserPreferences {
  darkMode: boolean;
  language: string;
  currency: string;
  timeZone: string;
  pushNotificationsEnabled: boolean;
  smsNotificationsEnabled?: boolean; // சில பிராந்தியங்களில் விருப்பமானது
  marketingEmailsEnabled?: boolean;
  regionSpecificPreference?: any; // நெகிழ்வான பிராந்திய-குறிப்பிட்ட விருப்பத்தேர்வு
}

function updateUserPreferences(userId: number, preferences: Partial<UserPreferences>): void {
  // Simulate updating user preferences in the database
  console.log(`Updating preferences for user ${userId}:`, preferences);
}


updateUserPreferences(1, {
    darkMode: true,
    language: "en-US",
    currency: "USD",
    timeZone: "America/Los_Angeles"
});


updateUserPreferences(2, {
  darkMode: false,
  language: "fr-CA",
  currency: "CAD",
  timeZone: "America/Toronto",
  smsNotificationsEnabled: true // கனடாவில் இயக்கப்பட்டது
});

UserPreferences இன்டர்ஃபேஸ், smsNotificationsEnabled மற்றும் marketingEmailsEnabled போன்ற விருப்பப் பண்புகளைப் பயன்படுத்துகிறது, அவை சில பிராந்தியங்களில் மட்டுமே பொருத்தமானதாக இருக்கலாம். regionSpecificPreference புலம் பிராந்திய-குறிப்பிட்ட அமைப்புகளைச் சேர்ப்பதற்கு மேலும் நெகிழ்வுத்தன்மையை வழங்குகிறது.

முடிவுரை

டைப்ஸ்கிரிப்ட்டின் Partial வகை நெகிழ்வான மற்றும் பராமரிக்கக்கூடிய குறியீட்டை உருவாக்குவதற்கான ஒரு பல்துறை கருவியாகும். விருப்பப் பண்புகளை வரையறுக்க உங்களை அனுமதிப்பதன் மூலம், இது ஆப்ஜெக்ட் கையாளுதல், API தொடர்புகள் மற்றும் தரவுக் கையாளுதலை எளிதாக்குகிறது. Partial-ஐ எவ்வாறு திறம்படப் பயன்படுத்துவது என்பதைப் புரிந்துகொள்வது, மற்ற பயன்பாட்டு வகைகளுடன் அதன் இணைப்புகளுடன், உங்கள் டைப்ஸ்கிரிப்ட் மேம்பாட்டுப் பணிப்பாய்வுகளை கணிசமாக மேம்படுத்தும். அதை புத்திசாலித்தனமாகப் பயன்படுத்தவும், அதன் நோக்கத்தைத் தெளிவாக ஆவணப்படுத்தவும், சாத்தியமான ஆபத்துக்களைத் தவிர்க்க தரவைச் சரிபார்க்கவும் நினைவில் கொள்ளுங்கள். உலகளாவிய பயன்பாடுகளை உருவாக்கும்போது, மாற்றியமைக்கக்கூடிய மற்றும் பயனர்-நட்பு தீர்வுகளுக்கு Partial வகைகளைப் பயன்படுத்த வெவ்வேறு பிராந்தியங்கள் மற்றும் கலாச்சாரங்களின் மாறுபட்ட தேவைகளைக் கருத்தில் கொள்ளுங்கள். Partial வகைகளில் தேர்ச்சி பெறுவதன் மூலம், நீங்கள் பல்வேறு சூழ்நிலைகளை நேர்த்தியாகவும் துல்லியமாகவும் கையாளக்கூடிய மேலும் வலுவான, மாற்றியமைக்கக்கூடிய மற்றும் பராமரிக்கக்கூடிய டைப்ஸ்கிரிப்ட் குறியீட்டை எழுதலாம்.